{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "746bb131",
   "metadata": {
    "_kg_hide-output": true,
    "execution": {
     "iopub.execute_input": "2024-11-11T10:45:10.635414Z",
     "iopub.status.busy": "2024-11-11T10:45:10.634618Z",
     "iopub.status.idle": "2024-11-11T10:45:24.062397Z",
     "shell.execute_reply": "2024-11-11T10:45:24.061191Z"
    },
    "papermill": {
     "duration": 13.436307,
     "end_time": "2024-11-11T10:45:24.064797",
     "exception": false,
     "start_time": "2024-11-11T10:45:10.628490",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "! pip install -q umap-learn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cefad83c",
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
    "execution": {
     "iopub.execute_input": "2024-11-11T10:45:24.075138Z",
     "iopub.status.busy": "2024-11-11T10:45:24.074484Z",
     "iopub.status.idle": "2024-11-11T10:45:24.083286Z",
     "shell.execute_reply": "2024-11-11T10:45:24.082429Z"
    },
    "papermill": {
     "duration": 0.016168,
     "end_time": "2024-11-11T10:45:24.085436",
     "exception": false,
     "start_time": "2024-11-11T10:45:24.069268",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing loss.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile loss.py\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "\n",
    "class LabelDifference(nn.Module):\n",
    "    def __init__(self, distance_type=\"l1\"):\n",
    "        super(LabelDifference, self).__init__()\n",
    "        self.distance_type = distance_type\n",
    "\n",
    "    def forward(self, labels):\n",
    "        # labels: [bs, label_dim]\n",
    "        # output: [bs, bs]\n",
    "        if self.distance_type == \"l1\":\n",
    "            return torch.abs(labels[:, None, :] - labels[None, :, :]).sum(dim=-1)\n",
    "        else:\n",
    "            raise ValueError(self.distance_type)\n",
    "\n",
    "\n",
    "class FeatureSimilarity(nn.Module):\n",
    "    def __init__(self, similarity_type=\"l2\"):\n",
    "        super(FeatureSimilarity, self).__init__()\n",
    "        self.similarity_type = similarity_type\n",
    "\n",
    "    def forward(self, features):\n",
    "        # labels: [bs, feat_dim]\n",
    "        # output: [bs, bs]\n",
    "        if self.similarity_type == \"l2\":\n",
    "            return -(features[:, None, :] - features[None, :, :]).norm(2, dim=-1)\n",
    "        else:\n",
    "            raise ValueError(self.similarity_type)\n",
    "\n",
    "\n",
    "class RnCLoss(nn.Module):\n",
    "    def __init__(self, temperature=2, label_diff=\"l1\", feature_sim=\"l2\"):\n",
    "        super(RnCLoss, self).__init__()\n",
    "        self.t = temperature\n",
    "        self.label_diff_fn = LabelDifference(label_diff)\n",
    "        self.feature_sim_fn = FeatureSimilarity(feature_sim)\n",
    "\n",
    "    def forward(self, features, labels):\n",
    "        # features: [bs, 2, feat_dim]\n",
    "        # labels: [bs, label_dim]\n",
    "\n",
    "        features = torch.cat([features[:, 0], features[:, 1]], dim=0)  # [2bs, feat_dim]\n",
    "        labels = labels.repeat(2, 1)  # [2bs, label_dim]\n",
    "\n",
    "        label_diffs = self.label_diff_fn(labels)\n",
    "        logits = self.feature_sim_fn(features).div(self.t)\n",
    "        logits_max, _ = torch.max(logits, dim=1, keepdim=True)\n",
    "        logits -= logits_max.detach()\n",
    "        exp_logits = logits.exp()\n",
    "\n",
    "        n = logits.shape[0]  # n = 2bs\n",
    "\n",
    "        # remove diagonal\n",
    "        logits = logits.masked_select((1 - torch.eye(n).to(logits.device)).bool()).view(\n",
    "            n, n - 1\n",
    "        )\n",
    "        exp_logits = exp_logits.masked_select(\n",
    "            (1 - torch.eye(n).to(logits.device)).bool()\n",
    "        ).view(n, n - 1)\n",
    "        label_diffs = label_diffs.masked_select(\n",
    "            (1 - torch.eye(n).to(logits.device)).bool()\n",
    "        ).view(n, n - 1)\n",
    "\n",
    "        loss = 0.0\n",
    "        for k in range(n - 1):\n",
    "            pos_logits = logits[:, k]  # 2bs\n",
    "            pos_label_diffs = label_diffs[:, k]  # 2bs\n",
    "            neg_mask = (\n",
    "                label_diffs >= pos_label_diffs.view(-1, 1)\n",
    "            ).float()  # [2bs, 2bs - 1]\n",
    "            pos_log_probs = pos_logits - torch.log(\n",
    "                (neg_mask * exp_logits).sum(dim=-1)\n",
    "            )  # 2bs\n",
    "            loss += -(pos_log_probs / (n * (n - 1))).sum()\n",
    "\n",
    "        return loss\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fd0454b1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T10:45:24.095801Z",
     "iopub.status.busy": "2024-11-11T10:45:24.095365Z",
     "iopub.status.idle": "2024-11-11T10:45:24.104274Z",
     "shell.execute_reply": "2024-11-11T10:45:24.103359Z"
    },
    "papermill": {
     "duration": 0.016806,
     "end_time": "2024-11-11T10:45:24.106357",
     "exception": false,
     "start_time": "2024-11-11T10:45:24.089551",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing convnext.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile convnext.py\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from timm.layers import DropPath, trunc_normal_\n",
    "\n",
    "\n",
    "class Block(nn.Module):\n",
    "    def __init__(self, dim, drop_path=0.0, layer_scale_init_value=1e-6):\n",
    "        super().__init__()\n",
    "        self.dwconv = nn.Conv1d(\n",
    "            dim, dim, kernel_size=7, padding=3, groups=dim\n",
    "        )  # depthwise conv\n",
    "        self.norm = LayerNorm(dim, eps=1e-6)\n",
    "        self.pwconv1 = nn.Linear(\n",
    "            dim, 4 * dim\n",
    "        )  # pointwise conv, implemented with linear layers\n",
    "        self.act = nn.GELU()\n",
    "        self.pwconv2 = nn.Linear(4 * dim, dim)\n",
    "        self.gamma = (\n",
    "            nn.Parameter(layer_scale_init_value * torch.ones((dim)), requires_grad=True)\n",
    "            if layer_scale_init_value > 0\n",
    "            else None\n",
    "        )\n",
    "        self.drop_path = DropPath(drop_path) if drop_path > 0.0 else nn.Identity()\n",
    "\n",
    "    def forward(self, x):\n",
    "        input = x\n",
    "        x = self.dwconv(x)\n",
    "        x = x.permute(0, 2, 1)  # (N, C, W) -> (N, W, C)\n",
    "        x = self.norm(x)\n",
    "        x = self.pwconv1(x)\n",
    "        x = self.act(x)\n",
    "        x = self.pwconv2(x)\n",
    "        if self.gamma is not None:\n",
    "            x = self.gamma * x\n",
    "        x = x.permute(0, 2, 1)  # (N, W, C) -> (N, C, W)\n",
    "        x = input + self.drop_path(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class ConvNeXt(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        in_chans=1,\n",
    "        num_classes=1000,\n",
    "        depths=[3, 3, 9, 3],\n",
    "        dims=[96, 192, 384, 768],\n",
    "        drop_path_rate=0.0,\n",
    "        layer_scale_init_value=1e-6,\n",
    "        head_init_scale=1.0,\n",
    "    ):\n",
    "        super().__init__()\n",
    "\n",
    "        self.downsample_layers = (\n",
    "            nn.ModuleList()\n",
    "        )  # stem and 3 intermediate downsampling conv layers\n",
    "        stem = nn.Sequential(\n",
    "            nn.Conv1d(in_chans, dims[0], kernel_size=4, stride=4),\n",
    "            LayerNorm(dims[0], eps=1e-6, data_format=\"channels_first\"),\n",
    "        )\n",
    "        self.downsample_layers.append(stem)\n",
    "        for i in range(3):\n",
    "            downsample_layer = nn.Sequential(\n",
    "                LayerNorm(dims[i], eps=1e-6, data_format=\"channels_first\"),\n",
    "                nn.Conv1d(dims[i], dims[i + 1], kernel_size=2, stride=2),\n",
    "            )\n",
    "            self.downsample_layers.append(downsample_layer)\n",
    "\n",
    "        self.stages = (\n",
    "            nn.ModuleList()\n",
    "        )  # 4 feature resolution stages, each consisting of multiple residual blocks\n",
    "        dp_rates = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]\n",
    "        cur = 0\n",
    "        for i in range(4):\n",
    "            stage = nn.Sequential(\n",
    "                *[\n",
    "                    Block(\n",
    "                        dim=dims[i],\n",
    "                        drop_path=dp_rates[cur + j],\n",
    "                        layer_scale_init_value=layer_scale_init_value,\n",
    "                    )\n",
    "                    for j in range(depths[i])\n",
    "                ]\n",
    "            )\n",
    "            self.stages.append(stage)\n",
    "            cur += depths[i]\n",
    "\n",
    "        self.norm = nn.LayerNorm(dims[-1], eps=1e-6)  # final norm layer\n",
    "        self.head = nn.Linear(dims[-1], num_classes)\n",
    "\n",
    "        self.apply(self._init_weights)\n",
    "        self.head.weight.data.mul_(head_init_scale)\n",
    "        self.head.bias.data.mul_(head_init_scale)\n",
    "\n",
    "    def _init_weights(self, m):\n",
    "        if isinstance(m, (nn.Conv1d, nn.Linear)):\n",
    "            trunc_normal_(m.weight, std=0.02)\n",
    "            nn.init.constant_(m.bias, 0)\n",
    "\n",
    "    def forward_features(self, x):\n",
    "        for i in range(4):\n",
    "            x = self.downsample_layers[i](x)\n",
    "            x = self.stages[i](x)\n",
    "        return self.norm(x.mean(-1))  # global average pooling, (N, C, W) -> (N, C)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.forward_features(x)\n",
    "        x = self.head(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, normalized_shape, eps=1e-6, data_format=\"channels_last\"):\n",
    "        super().__init__()\n",
    "        self.weight = nn.Parameter(torch.ones(normalized_shape))\n",
    "        self.bias = nn.Parameter(torch.zeros(normalized_shape))\n",
    "        self.eps = eps\n",
    "        self.data_format = data_format\n",
    "        if self.data_format not in [\"channels_last\", \"channels_first\"]:\n",
    "            raise NotImplementedError\n",
    "        self.normalized_shape = (normalized_shape,)\n",
    "\n",
    "    def forward(self, x):\n",
    "        if self.data_format == \"channels_last\":\n",
    "            return F.layer_norm(\n",
    "                x, self.normalized_shape, self.weight, self.bias, self.eps\n",
    "            )\n",
    "        elif self.data_format == \"channels_first\":\n",
    "            u = x.mean(1, keepdim=True)\n",
    "            s = (x - u).pow(2).mean(1, keepdim=True)\n",
    "            x = (x - u) / torch.sqrt(s + self.eps)\n",
    "            x = self.weight[:, None] * x + self.bias[:, None]\n",
    "            return x\n",
    "\n",
    "\n",
    "def convnext_tiny(**kwargs):\n",
    "    model = ConvNeXt(depths=[3, 3, 9, 3], dims=[96, 192, 384, 768], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def convnext_small(**kwargs):\n",
    "    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[96, 192, 384, 768], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def convnext_base(**kwargs):\n",
    "    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[128, 256, 512, 1024], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def convnext_large(**kwargs):\n",
    "    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[192, 384, 768, 1536], **kwargs)\n",
    "    return model\n",
    "\n",
    "\n",
    "def convnext_xlarge(**kwargs):\n",
    "    model = ConvNeXt(depths=[3, 3, 27, 3], dims=[256, 512, 1024, 2048], **kwargs)\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8a9d4ccc",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T10:45:24.116612Z",
     "iopub.status.busy": "2024-11-11T10:45:24.115918Z",
     "iopub.status.idle": "2024-11-11T10:45:24.123045Z",
     "shell.execute_reply": "2024-11-11T10:45:24.122103Z"
    },
    "papermill": {
     "duration": 0.014648,
     "end_time": "2024-11-11T10:45:24.125249",
     "exception": false,
     "start_time": "2024-11-11T10:45:24.110601",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing ppg_dalia.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile ppg_dalia.py\n",
    "import glob\n",
    "import os\n",
    "\n",
    "import mne\n",
    "import numpy as np\n",
    "import torch\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torch.utils.data import Dataset\n",
    "\n",
    "data_dir = \"/kaggle/input/ppg-dalia-processed\"\n",
    "filepaths = glob.glob(os.path.join(data_dir, \"*.npz\"))\n",
    "\n",
    "# 80%-10%-10%\n",
    "train_files, test_files = train_test_split(\n",
    "    filepaths,\n",
    "    test_size=0.2,\n",
    "    shuffle=True,\n",
    "    random_state=42,\n",
    ")\n",
    "val_files, test_files = train_test_split(\n",
    "    test_files,\n",
    "    test_size=0.5,\n",
    "    shuffle=True,\n",
    "    random_state=42,\n",
    ")\n",
    "\n",
    "files = {\n",
    "    \"train\": train_files,\n",
    "    \"val\": val_files,\n",
    "    \"test\": test_files,\n",
    "}\n",
    "ecgs = {\"train\": [], \"val\": [], \"test\": []}\n",
    "ppgs = {\"train\": [], \"val\": [], \"test\": []}\n",
    "\n",
    "labels = {\"train\": [], \"val\": [], \"test\": []}\n",
    "\n",
    "for split in [\"train\", \"val\", \"test\"]:\n",
    "    for file in files[split]:\n",
    "        data = np.load(file)\n",
    "        ecg = data[\"ecg\"]\n",
    "        ppg = data[\"ppg\"]\n",
    "        label = data[\"label\"]\n",
    "        ecg_resampled = mne.filter.resample(ecg.astype(float), down=700 / 64)\n",
    "\n",
    "        ecgs[split].append(ecg_resampled)\n",
    "        ppgs[split].append(ppg)\n",
    "        labels[split].append(label)\n",
    "\n",
    "    ecgs[split] = np.concatenate(ecgs[split], axis=0)\n",
    "    ppgs[split] = np.concatenate(ppgs[split], axis=0)\n",
    "    labels[split] = np.concatenate(labels[split], axis=0)\n",
    "\n",
    "mean, std = labels[\"train\"].mean(), labels[\"train\"].std()\n",
    "\n",
    "\n",
    "def normalize_labels(label):\n",
    "    return (label - mean) / std\n",
    "\n",
    "\n",
    "def unnormalize_labels(label):\n",
    "    return std * label + mean\n",
    "\n",
    "\n",
    "class PPG_DaLiA(Dataset):\n",
    "\n",
    "    def __init__(self, ecgs, ppgs, labels):\n",
    "        self.ecgs = (ecgs - np.min(ecgs)) / (np.max(ecgs) - np.min(ecgs))\n",
    "        self.ppgs = (ppgs - np.min(ppgs)) / (np.max(ppgs) - np.min(ppgs))\n",
    "        self.labels = normalize_labels(labels)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.labels)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        ecg = torch.as_tensor(self.ecgs[index], dtype=torch.float32)\n",
    "        ppg = torch.as_tensor(self.ppgs[index], dtype=torch.float32)\n",
    "        label = torch.as_tensor(self.labels[index], dtype=torch.float32)\n",
    "\n",
    "        ecg = ecg.unsqueeze(0)\n",
    "        ppg = ppg.unsqueeze(0)\n",
    "        label = label.unsqueeze(0)\n",
    "\n",
    "        return ecg, ppg, label\n",
    "\n",
    "\n",
    "dataset = {\n",
    "    \"train\": PPG_DaLiA(ecgs[\"train\"], ppgs[\"train\"], labels[\"train\"]),\n",
    "    \"val\": PPG_DaLiA(ecgs[\"val\"], ppgs[\"val\"], labels[\"val\"]),\n",
    "    \"test\": PPG_DaLiA(ecgs[\"test\"], ppgs[\"test\"], labels[\"test\"]),\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "245c496b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T10:45:24.135159Z",
     "iopub.status.busy": "2024-11-11T10:45:24.134820Z",
     "iopub.status.idle": "2024-11-11T11:25:56.988671Z",
     "shell.execute_reply": "2024-11-11T11:25:56.987617Z"
    },
    "papermill": {
     "duration": 2432.862218,
     "end_time": "2024-11-11T11:25:56.991650",
     "exception": false,
     "start_time": "2024-11-11T10:45:24.129432",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model params: 2.86 M\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "460946f415204a539dc51f120db7e3de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/32160 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch=0, Train/Loss=2.79, Val/MAE=15.86\n",
      "Epoch=1, Train/Loss=2.40, Val/MAE=10.90\n",
      "Epoch=2, Train/Loss=2.27, Val/MAE=11.76\n",
      "Epoch=3, Train/Loss=2.20, Val/MAE=7.93\n",
      "Epoch=4, Train/Loss=2.14, Val/MAE=8.95\n",
      "Epoch=5, Train/Loss=2.09, Val/MAE=10.59\n",
      "Epoch=6, Train/Loss=2.04, Val/MAE=8.71\n",
      "Epoch=7, Train/Loss=2.00, Val/MAE=9.17\n",
      "Epoch=8, Train/Loss=1.95, Val/MAE=9.13\n",
      "Epoch=9, Train/Loss=1.90, Val/MAE=10.77\n",
      "Epoch=10, Train/Loss=1.86, Val/MAE=10.00\n",
      "Epoch=11, Train/Loss=1.82, Val/MAE=8.62\n",
      "Epoch=12, Train/Loss=1.77, Val/MAE=9.64\n",
      "Epoch=13, Train/Loss=1.77, Val/MAE=10.12\n",
      "Epoch=14, Train/Loss=1.70, Val/MAE=9.11\n",
      "Epoch=15, Train/Loss=1.68, Val/MAE=8.83\n",
      "Epoch=16, Train/Loss=1.66, Val/MAE=8.56\n",
      "Epoch=17, Train/Loss=1.63, Val/MAE=10.39\n",
      "Epoch=18, Train/Loss=1.60, Val/MAE=10.01\n",
      "Epoch=19, Train/Loss=1.58, Val/MAE=8.35\n"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torchmetrics.aggregation import MeanMetric\n",
    "from tqdm.auto import tqdm\n",
    "\n",
    "from convnext import ConvNeXt\n",
    "from loss import RnCLoss\n",
    "from ppg_dalia import dataset, unnormalize_labels\n",
    "\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "batch_size = 32\n",
    "train_loader = DataLoader(dataset[\"train\"], batch_size=batch_size, shuffle=True)\n",
    "val_loader = DataLoader(dataset[\"val\"], batch_size=batch_size)\n",
    "test_loader = DataLoader(dataset[\"test\"], batch_size=batch_size)\n",
    "\n",
    "ecg_enc = ConvNeXt(depths=[3, 3, 9, 3], dims=[32, 64, 128, 256], num_classes=1)\n",
    "ecg_enc.to(device)\n",
    "\n",
    "ppg_enc = ConvNeXt(depths=[3, 3, 9, 3], dims=[32, 64, 128, 256], num_classes=1)\n",
    "ppg_enc.to(device)\n",
    "\n",
    "model_size = 0\n",
    "for param in ppg_enc.parameters():\n",
    "    model_size += param.data.nelement()\n",
    "print(\"Model params: %.2f M\" % (model_size / 1024 / 1024))\n",
    "\n",
    "# Pretraining: Rank-N-Constrast\n",
    "epochs = 20\n",
    "lr = 3e-4\n",
    "optimizer_ppg = torch.optim.Adam(ppg_enc.parameters(), lr=lr)\n",
    "optimizer_ecg = torch.optim.Adam(ecg_enc.parameters(), lr=lr)\n",
    "criterion = RnCLoss(temperature=2, label_diff=\"l1\", feature_sim=\"l2\")\n",
    "\n",
    "avg_loss = MeanMetric()\n",
    "train_losses = []\n",
    "val_mae = []\n",
    "\n",
    "pbar = tqdm(total=epochs*len(train_loader))\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    for ecgs, ppgs, labels in train_loader:\n",
    "        ecgs = ecgs.to(device)\n",
    "        ppgs = ppgs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        ecg_feats = ecg_enc.forward_features(ppgs)\n",
    "        ppg_feats = ppg_enc.forward_features(ppgs)\n",
    "        feats = torch.stack([ecg_feats, ppg_feats], dim=1)\n",
    "        rnc_loss = criterion(feats, labels)\n",
    "        \n",
    "        preds = ppg_enc.head(ppg_feats)\n",
    "        l2_loss = F.mse_loss(preds, labels)\n",
    "        \n",
    "        loss = 0.2*l2_loss + 0.8*rnc_loss\n",
    "\n",
    "        optimizer_ecg.zero_grad()\n",
    "        optimizer_ppg.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer_ecg.step()\n",
    "        optimizer_ppg.step()\n",
    "\n",
    "        train_losses.append(loss.item())\n",
    "        avg_loss.update(loss.item())\n",
    "        pbar.update()\n",
    "    \n",
    "    batched_errors = []\n",
    "    for _, inputs, labels in val_loader:\n",
    "        inputs = inputs.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            preds = ppg_enc(inputs)\n",
    "\n",
    "        errors = F.l1_loss(\n",
    "            unnormalize_labels(preds),\n",
    "            unnormalize_labels(labels),\n",
    "            reduction=\"none\",\n",
    "        )\n",
    "        batched_errors.append(errors.cpu().numpy())\n",
    "\n",
    "    batched_errors = np.concatenate(batched_errors, axis=0)\n",
    "    mae = np.mean(batched_errors)\n",
    "    val_mae.append(mae)\n",
    "    \n",
    "    print(f\"Epoch={epoch}, Train/Loss={avg_loss.compute():.2f}, Val/MAE={mae:.2f}\")\n",
    "    avg_loss.reset()\n",
    "\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fe143623",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:25:57.007334Z",
     "iopub.status.busy": "2024-11-11T11:25:57.006955Z",
     "iopub.status.idle": "2024-11-11T11:25:57.344702Z",
     "shell.execute_reply": "2024-11-11T11:25:57.343783Z"
    },
    "papermill": {
     "duration": 0.348095,
     "end_time": "2024-11-11T11:25:57.346960",
     "exception": false,
     "start_time": "2024-11-11T11:25:56.998865",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(train_losses)\n",
    "plt.xlabel(\"Step\")\n",
    "plt.title(\"Train/Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5a11d117",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:25:57.361996Z",
     "iopub.status.busy": "2024-11-11T11:25:57.361196Z",
     "iopub.status.idle": "2024-11-11T11:25:57.581010Z",
     "shell.execute_reply": "2024-11-11T11:25:57.580082Z"
    },
    "papermill": {
     "duration": 0.229695,
     "end_time": "2024-11-11T11:25:57.583141",
     "exception": false,
     "start_time": "2024-11-11T11:25:57.353446",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(val_mae)\n",
    "plt.xlabel(\"Step\")\n",
    "plt.title(\"Val/MAE\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "25e3e0d1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:25:57.599314Z",
     "iopub.status.busy": "2024-11-11T11:25:57.598645Z",
     "iopub.status.idle": "2024-11-11T11:25:59.856655Z",
     "shell.execute_reply": "2024-11-11T11:25:59.855461Z"
    },
    "papermill": {
     "duration": 2.268315,
     "end_time": "2024-11-11T11:25:59.858646",
     "exception": false,
     "start_time": "2024-11-11T11:25:57.590331",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test MAE: 8.233009\n"
     ]
    }
   ],
   "source": [
    "model = ppg_enc\n",
    "\n",
    "batched_errors = []\n",
    "for _, inputs, labels in test_loader:\n",
    "    inputs = inputs.to(device)\n",
    "    labels = labels.to(device)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        preds = model(inputs)\n",
    "\n",
    "    errors = F.l1_loss(\n",
    "        unnormalize_labels(preds), unnormalize_labels(labels), reduction='none',\n",
    "    )\n",
    "    batched_errors.append(errors.cpu().numpy())\n",
    "\n",
    "batched_errors = np.concatenate(batched_errors, axis=0)\n",
    "mae = np.mean(batched_errors)\n",
    "\n",
    "print(\"Test MAE:\", mae)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7257fc74",
   "metadata": {
    "papermill": {
     "duration": 0.006807,
     "end_time": "2024-11-11T11:25:59.872559",
     "exception": false,
     "start_time": "2024-11-11T11:25:59.865752",
     "status": "completed"
    },
    "tags": []
   },
   "source": [
    "## Examining Feature Space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6a81bbee",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:25:59.887918Z",
     "iopub.status.busy": "2024-11-11T11:25:59.887531Z",
     "iopub.status.idle": "2024-11-11T11:26:00.881177Z",
     "shell.execute_reply": "2024-11-11T11:26:00.880140Z"
    },
    "papermill": {
     "duration": 1.004195,
     "end_time": "2024-11-11T11:26:00.883603",
     "exception": false,
     "start_time": "2024-11-11T11:25:59.879408",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "batched_feats = []\n",
    "batched_labels = []\n",
    "for _, inputs, labels in val_loader:\n",
    "    inputs = inputs.to(device)\n",
    "    labels = labels.to(device)\n",
    "\n",
    "    with torch.no_grad():\n",
    "        feats = model.forward_features(inputs)\n",
    "    \n",
    "    batched_feats.append(feats.cpu())\n",
    "    batched_labels.append(labels.cpu())\n",
    "    \n",
    "feats = torch.cat(batched_feats, dim=0)\n",
    "labels = torch.cat(batched_labels, dim=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1e6070db",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:26:00.899465Z",
     "iopub.status.busy": "2024-11-11T11:26:00.899100Z",
     "iopub.status.idle": "2024-11-11T11:26:56.598855Z",
     "shell.execute_reply": "2024-11-11T11:26:56.597822Z"
    },
    "papermill": {
     "duration": 55.710429,
     "end_time": "2024-11-11T11:26:56.601355",
     "exception": false,
     "start_time": "2024-11-11T11:26:00.890926",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import umap\n",
    "\n",
    "feats_reduced = umap.UMAP().fit_transform(feats)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2a9bf17d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-11-11T11:26:56.618564Z",
     "iopub.status.busy": "2024-11-11T11:26:56.617827Z",
     "iopub.status.idle": "2024-11-11T11:26:57.037360Z",
     "shell.execute_reply": "2024-11-11T11:26:57.036450Z"
    },
    "papermill": {
     "duration": 0.431165,
     "end_time": "2024-11-11T11:26:57.040196",
     "exception": false,
     "start_time": "2024-11-11T11:26:56.609031",
     "status": "completed"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(\n",
    "    feats_reduced[:, 0],\n",
    "    feats_reduced[:, 1],\n",
    "    c=unnormalize_labels(labels).squeeze(),\n",
    "    cmap=\"magma\",\n",
    ")\n",
    "plt.colorbar()\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "datasetId": 5711874,
     "sourceId": 9407429,
     "sourceType": "datasetVersion"
    }
   ],
   "dockerImageVersionId": 30787,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  },
  "papermill": {
   "default_parameters": {},
   "duration": 2512.719747,
   "end_time": "2024-11-11T11:27:00.578395",
   "environment_variables": {},
   "exception": null,
   "input_path": "__notebook__.ipynb",
   "output_path": "__notebook__.ipynb",
   "parameters": {},
   "start_time": "2024-11-11T10:45:07.858648",
   "version": "2.6.0"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {
     "03eec81dfdd448daa6421f99b7eb3b18": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "1e63d6ccf75e45de93f48f0b9dd96eaf": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "2ddb7a5436b3435dae674a7de6c382e9": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "460946f415204a539dc51f120db7e3de": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HBoxModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HBoxModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HBoxView",
       "box_style": "",
       "children": [
        "IPY_MODEL_8713b8eaf0534b3cbbf6028f3d56df64",
        "IPY_MODEL_5cd6713df4b844558289b34eefb26b1c",
        "IPY_MODEL_ca319a27016843d791775eb8e5ae2397"
       ],
       "layout": "IPY_MODEL_9fbb83f65a5141aaa93f60dc7f5837ce"
      }
     },
     "5cd6713df4b844558289b34eefb26b1c": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "FloatProgressModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "FloatProgressModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "ProgressView",
       "bar_style": "success",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_03eec81dfdd448daa6421f99b7eb3b18",
       "max": 32160.0,
       "min": 0.0,
       "orientation": "horizontal",
       "style": "IPY_MODEL_d1428ee0e9f747d5885191d027240ee3",
       "value": 32160.0
      }
     },
     "86e97ebf5b4f4f1f97ed4405b9e6c4e1": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "DescriptionStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "DescriptionStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "description_width": ""
      }
     },
     "8713b8eaf0534b3cbbf6028f3d56df64": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_2ddb7a5436b3435dae674a7de6c382e9",
       "placeholder": "​",
       "style": "IPY_MODEL_86e97ebf5b4f4f1f97ed4405b9e6c4e1",
       "value": "100%"
      }
     },
     "9fbb83f65a5141aaa93f60dc7f5837ce": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "a5814e22371c4e028acb8bedfee5cb3b": {
      "model_module": "@jupyter-widgets/base",
      "model_module_version": "1.2.0",
      "model_name": "LayoutModel",
      "state": {
       "_model_module": "@jupyter-widgets/base",
       "_model_module_version": "1.2.0",
       "_model_name": "LayoutModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "LayoutView",
       "align_content": null,
       "align_items": null,
       "align_self": null,
       "border": null,
       "bottom": null,
       "display": null,
       "flex": null,
       "flex_flow": null,
       "grid_area": null,
       "grid_auto_columns": null,
       "grid_auto_flow": null,
       "grid_auto_rows": null,
       "grid_column": null,
       "grid_gap": null,
       "grid_row": null,
       "grid_template_areas": null,
       "grid_template_columns": null,
       "grid_template_rows": null,
       "height": null,
       "justify_content": null,
       "justify_items": null,
       "left": null,
       "margin": null,
       "max_height": null,
       "max_width": null,
       "min_height": null,
       "min_width": null,
       "object_fit": null,
       "object_position": null,
       "order": null,
       "overflow": null,
       "overflow_x": null,
       "overflow_y": null,
       "padding": null,
       "right": null,
       "top": null,
       "visibility": null,
       "width": null
      }
     },
     "ca319a27016843d791775eb8e5ae2397": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "HTMLModel",
      "state": {
       "_dom_classes": [],
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "HTMLModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/controls",
       "_view_module_version": "1.5.0",
       "_view_name": "HTMLView",
       "description": "",
       "description_tooltip": null,
       "layout": "IPY_MODEL_a5814e22371c4e028acb8bedfee5cb3b",
       "placeholder": "​",
       "style": "IPY_MODEL_1e63d6ccf75e45de93f48f0b9dd96eaf",
       "value": " 32160/32160 [40:03&lt;00:00, 13.56it/s]"
      }
     },
     "d1428ee0e9f747d5885191d027240ee3": {
      "model_module": "@jupyter-widgets/controls",
      "model_module_version": "1.5.0",
      "model_name": "ProgressStyleModel",
      "state": {
       "_model_module": "@jupyter-widgets/controls",
       "_model_module_version": "1.5.0",
       "_model_name": "ProgressStyleModel",
       "_view_count": null,
       "_view_module": "@jupyter-widgets/base",
       "_view_module_version": "1.2.0",
       "_view_name": "StyleView",
       "bar_color": null,
       "description_width": ""
      }
     }
    },
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
